//
//  KLStatus.swift
//  BCWeiBo
//
//  Created by bcmac3 on 16/4/5.
//  Copyright © 2016年 KellenYangs. All rights reserved.
//

import UIKit
import SDWebImage

private let WB_HOME_TIMELINE = "2/statuses/home_timeline.json"

class KLStatus: NSObject {

    /// 微博创建时间
    var created_at: String?{
        didSet{
            if let time = created_at{
//                print(time)
                /*
                // 1.获取微博的创建时间
                // 1.1创建格式化对象
                let formatter = NSDateFormatter()
                // 1.2指定时间格式
                formatter.dateFormat = "EEE MM dd HH:mm:ss Z yyyy"
                // 真机调试的时候必须加上(说明时间格式所属的区域)
                formatter.locale = NSLocale(localeIdentifier: "en")
                // 1.3将字符串(NSString)转成时间对象(NSDate)
                // 过滤掉时区的日期
                let date = formatter.dateFromString(time)
                print(date)
                */
                /*
                let date = NSDate.sinaDate(time)
                // 1.创建日历对象
                let calendar = NSCalendar.currentCalendar()
                // 2.取出指定时间的年月日
                let flag = NSCalendarUnit(rawValue: UInt.max)
                let comps = calendar.components(flag, fromDate: date!)
                print(comps.year)
                print(comps.month)
                
                */
                if time == ""
                {
                    return
                }
                // 通过字符串转换NSDate
                let date = NSDate.sinaDate(time)
                // 获取指定时间距离现在的时间差
                created_at = date!.dateDesctiption
            }
        }
    }
    /// 微博ID
    var id: Int = 0
    /// 微博信息内容
    var text: String?
    /// 微博来源
    var source: String?{
        didSet{
            // 注意: 可能为nil或者""
            if let str = source
            {
                if str == ""
                {
                    return 
                }
                // 截取中间字符串
                // 1.获取开始截取的位置位置
                let start = (str as NSString).rangeOfString(">").location + 1
                // 2.获取结束截取的位置
                let end =  (str as NSString).rangeOfString("</").location
                // 3.计算要截取字符串的长度
                let len = end - start
                
                // 4.截取字符串
                let res = (str as NSString).substringWithRange(NSMakeRange(start, len))
                // 5.重新赋值
                source = "来自: \(res)"
            }
        }
    }
    
    /// 配图数组
    var pic_urls: [[String: AnyObject]]?{
        didSet{
            // 1.判断数组中是否有数据 nil
            if pic_urls?.count == 0{
                return
            }
            // 2.实例化数组
            storedPictureURLs = [NSURL]()
            // 3.遍历字典生成 url 的数组
            for dict in pic_urls!{
                if let urlString = dict["thumbnail_pic"] as? String {
                    // 生成缩略图的 URL
                    storedPictureURLs?.append(NSURL(string: urlString)!)
                    
                    // 生成大图
                    let largeURLString = urlString.stringByReplacingOccurrencesOfString("thumbnail", withString: "large")
                    storedLargePictureURLs?.append(NSURL(string: largeURLString)!)
                    
                }
            }
        }
    }
    /// `保存`配图的 URL 的数组
    var storedPictureURLs: [NSURL]?

    /// 用户模型
    var user: KLUser?
    
    /// 转发微博
    var retweeted_status: KLStatus?
    
    /// 配图的URL的`计算型`数组
    /// 如果是原创微博，返回 storedPictureURLs
    /// 如果是转发微博，返回 retweeted_status.storedPictureURLs
    var pictureURLs: [NSURL]?{
        return retweeted_status != nil ? retweeted_status?.storedPictureURLs :  storedPictureURLs
    }
    /// `保存`配图的大图 URL 的数组
    private var storedLargePictureURLs: [NSURL]?
    
    /// 返回大图的 URL 数组
    var largePictureURLs: [NSURL]? {
        return retweeted_status == nil ? storedLargePictureURLs : retweeted_status?.storedLargePictureURLs
    }
    
    // 定义类属性数组
    static let properties = ["created_at", "id", "text", "source", "pic_urls", "user"]
    
    // 自定义构造函数
    init(dict: [String: AnyObject]){
        super.init()
        // 会调用 setValue forKey 给每一个属性赋值
        setValuesForKeysWithDictionary(dict)
    }
    
    class func loadStatuses(since_id: Int, max_id: Int, finished: (statuses: [KLStatus]?, error: NSError?)->()){
        
        KLStatusDAO.loadStatuses(since_id, max_id: max_id) { (array, error) -> () in
            
            if array == nil
            {
                finished(statuses: nil, error: error)
            }
            
            if error != nil
            {
                finished(statuses: nil, error: error)
            }
            
            // 2.遍历数组, 将字典转换为模型
            let models = status(array!)
            
            // 3.缓存微博配图
            cacheWebImage(models, finished: finished)
        }

        /*
        var params = ["access_token": KLUserAccount.loadAccount()!.access_token!]
        // 设置since_id
        if since_id > 0
        {
            params["since_id"] = "\(since_id)"
        }
        
        // 设置max_id
        if max_id > 0
        {
            params["max_id"] = "\(max_id - 1)"
        }
        
        KLNetworkTools.sharedNetworkTools().GET(WB_HOME_TIMELINE, parameters: params, success: { (_, JSON) -> Void in
            // 字典转换模型
            if let statuses = JSON!["statuses"] as? [[String: AnyObject]] {
                let models = KLStatus.status(statuses)
//                print(JSON)
//                print(models)
                cacheWebImage(models, finished: finished)
            }
            
            }) { (_, error) -> Void in
                print(error)
                finished(statuses: nil, error: error)
        }
        */
    }
    
    /// 缓存微博的网络图片，缓存结束之后，才刷新数据
    private class func cacheWebImage(list: [KLStatus], finished: (statuses: [KLStatus]?, error: NSError?)->())
    {
        if list.count == 0
        {
            finished(statuses: list, error: nil)
        }
        // 创建调度组
        let group = dispatch_group_create()
        
        for status in list{
            // guard语句的作用到底是什么呢？顾名思义，就是守护。guard语句判断其后的表达式布尔值为false时，才会执行之后代码块里的代码，如果为true，则跳过整个guard语句
            guard let _ = status.storedPictureURLs else
            {
                continue
            }
            
            // 下载图片
            for url in status.storedPictureURLs!
            {
                // 加入调度组
                dispatch_group_enter(group)
                
                SDWebImageManager.sharedManager().downloadImageWithURL(url, options: SDWebImageOptions(rawValue: 0), progress: nil, completed: { (_, _, _, _, _) -> Void in
                    // 离开调度组
                    dispatch_group_leave(group)
                })
            }
            
            // 监听所有缓存操作的通知
            dispatch_group_notify(group, dispatch_get_main_queue()) { () -> Void in
                // 获得完整的微博数组，可以回调
                // 回调通知调用者
                finished(statuses: list, error: nil)
            }
        }
    }
    
    /// 使用传入数组完成字典转模型
    private class func status(array: [[String:AnyObject]]) -> [KLStatus]{
        var models = [KLStatus]()
        for dict in array{
            models.append(KLStatus(dict: dict))
        }
        return models
    }
    
    override func setValue(value: AnyObject?, forKey key: String) {
        // 判断 key 是否是 user，如果是 user 单独处理
        if key == "user"{
            // 判断 value 是否是一个有效的字典
            if let dict = value as? [String: AnyObject]{
                // 创建用户数据
                user = KLUser(dict: dict)
            }
            return
        }
        
        // 判断 key 是否是 retweeted_status 是否为空
        // 转发微博最多只会执行一次
        if key == "retweeted_status" {
            if let dict = value as? [String: AnyObject] {
                retweeted_status = KLStatus(dict: dict)
            }
            return
        }
        
        // 如果不是调用父类方法进行默认处理
        super.setValue(value, forKey: key)
    }
    // 如果没有对应的key会调用这个方法
    override func setValue(value: AnyObject?, forUndefinedKey key: String){
//        print("找不到\(key)")
    }
    // 打印对象
    override var description: String{
        return "\(self.dictionaryWithValuesForKeys(KLStatus.properties))"
    }
    
}
